﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Windows;
using System.Windows.Input;
using CalculoPreciosUnitarios.Logica.GestorBaseDeDatos.CotizarArticulos;
using CalculoPreciosUnitarios.Logica.GestorBaseDeDatos.Rubro;
using CalculoPreciosUnitarios.Logica.GestorObject.CotizarArticulos;
using CalculoPreciosUnitarios.Logica.GestorObject.Rubro;
using CalculoPreciosUnitarios.Ventanas.Listados;

namespace CalculoPreciosUnitarios.Ventanas.Rubro
{
    /// <summary>
    /// Lógica de interacción para NuevoRubro.xaml
    /// </summary>
    public partial class NuevoRubro : Window
    {
        #region Property

        private RubroCS _rubro = new RubroCS();

        private List<SubRubroCS> subRubros = new List<SubRubroCS>();
        private SubRubroCS _subRubro = new SubRubroCS();

        private bool forzadoAgregarRubro = false;
        private bool forzadoAgregarSubRubro = false;

        //Bases de Datos
        private RubroDB rubroDB = new RubroDB();
        private CotizarArticulosDB cotizarDB = new CotizarArticulosDB();


        #endregion

        #region Constructor

        public NuevoRubro()
        {
            InitializeComponent();
            AddHandler(Keyboard.KeyDownEvent, (KeyEventHandler)HandleKeyDownEvent);
            DataContext = _rubro;
            ReasignarDataContext(_subRubro);
            this.codigoRubroValue.Focus();
            CargarTodosSubRubros();
            _rubro.PropertyChanged += new PropertyChangedEventHandler(rubroPropertyChanged);
            _subRubro.PropertyChanged += new PropertyChangedEventHandler(subRubroPropertyChanged);
            
        }

        #endregion

        #region Windows Methods

        private void HandleKeyDownEvent(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.P && (Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control)
            {
                Listar();
            }
        }

        #region Botones

        private void btnCambiarCodigoRubro_Click(object sender, RoutedEventArgs e)
        {
            CambiarCodigoRubro();
        }

        private void btnListado_Click(object sender, RoutedEventArgs e)
        {
            Listar();
        }

        private void btnSalir_Click(object sender, RoutedEventArgs e)
        {
            Salir();
        }

        #endregion

        #region Eventos

        private void dataGridSubRubros_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
        {
            SubRubroCS auxSubRubro = (SubRubroCS)dataGridSubRubros.SelectedItem;

            if (dataGridSubRubros.SelectedIndex >= 0)
            {
                _subRubro = rubroDB.ObtenerSubRubroPorCodigo(auxSubRubro);

                RubroCS auxiliarRubro = new RubroCS();
                auxiliarRubro.IdRubro = _subRubro.IdRubro;

                if(!string.IsNullOrEmpty(auxiliarRubro.IdRubro))
                {
                    this.codigoRubroValue.Text = auxiliarRubro.IdRubro;
                    this.detalleRubroValue.Text = rubroDB.ObtenerRubroPorCodigoExacto(auxiliarRubro).Descripcion;
                    this.codigoSubRubroValue.Text = _subRubro.IdSubRubro;
                    this.detalleSubRubroValue.Text = _subRubro.Descripcion;
                    this.precioSubRubroValue.Text = _subRubro.Precio.ToString();
                
                    ReasignarDataContext(_subRubro);
                    BotonesRubroModoModificar();
                    BotonesSubRubroModoModificar();
                }
            }
            
        }

        private void Window_KeyDown(object sender, KeyEventArgs e)
        {
            switch (e.Key.ToString().ToUpper())
            {
                case "F2":
                    detalleRubroValue.Text = "";
                    LimpiarCamposSubRubros();
                    LimpiarDataGrid();
                    BotonesRubroModoAgregar();
                    BotonesSubRubroModoAgregar();
                    forzadoAgregarRubro = true;
                    break;
                case "F3":
                    if (this.btnAgregarRubro.IsEnabled)
                    {
                        AgregarRubro();
                    }
                    break;
                case "F4":
                    ModificarRubro();
                    break;
                case "F5":
                    EliminarRubro();
                    break;
                case "F6":
                    CambiarCodigoRubro();
                    break;
                case "F7":
                    if (this.btnAgregarSubRubro.IsEnabled)
                    {
                        AgregarSubRubro();
                    }
                    break;
                case "F8":
                    ModificarSubRubro();
                    break;
                case "F9":
                    EliminarSubRubro();
                    break;
                case "F11":
                    CambiarCodigoSubRubro();
                    break;
                case "ESCAPE":
                    Salir();
                    break;
                default:
                    return;
            }
        }

        private void rubroPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if(codigoRubroValue.Text.Length > 1)
            {
                RubroCS auxRubro = new RubroCS();
                auxRubro.IdRubro = AdaptarString(codigoRubroValue.Text);
                if (forzadoAgregarRubro)
                {
                    auxRubro = rubroDB.ObtenerRubroPorCodigoExacto(auxRubro);
                }
                else
                {
                    auxRubro = rubroDB.ObtenerRubroPorCodigo(auxRubro);
                }

                btnAgregarRubro.IsEnabled = _rubro.IsValid() && auxRubro.IdRubro.Equals("");
            }
            
        }

        private void subRubroPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (codigoRubroValue.Text.Length > 1 && codigoSubRubroValue.Text.Length > 0)
            {
                SubRubroCS auxSubRubro = new SubRubroCS();
                auxSubRubro.IdRubro = AdaptarString(codigoRubroValue.Text);
                auxSubRubro.IdSubRubro = AdaptarString(codigoSubRubroValue.Text);
                auxSubRubro = rubroDB.ObtenerSubRubroPorCodigo(auxSubRubro);

                btnAgregarSubRubro.IsEnabled = _subRubro.IsValid() && (auxSubRubro.IdRubro.Equals("") && auxSubRubro.IdSubRubro.Equals(""));
            }
        }

        #endregion

        #region Rubro Windows

        private void codigoRubroValue_KeyUp(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter)
            {
                BuscarRubroPorCodigo();
            } 
        }

        private void detalleRubroValue_KeyUp(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter)
            {
                BuscarRubroPorDescripcion();
            }
        }

        private void btnAgregarRubro_Click(object sender, RoutedEventArgs e)
        {
            AgregarRubro();
        }

        private void btnModificarRubro_Click(object sender, RoutedEventArgs e)
        {
            ModificarRubro();
        }
        private void btnEliminarRubro_Click(object sender, RoutedEventArgs e)
        {
            EliminarRubro();
        }

        private void btnLimpiarRubro_Click(object sender, RoutedEventArgs e)
        {
            LimpiarCamposRubro();
        }

        private void codigoRubroValue_GotFocus(object sender, RoutedEventArgs e)
        {
            codigoRubroValue.SelectionLength = codigoRubroValue.Text.Length;
        }

        private void detalleRubroValue_GotFocus(object sender, RoutedEventArgs e)
        {
            detalleRubroValue.SelectionLength = detalleRubroValue.Text.Length;
        }

        #endregion

        #region SubRubro Windows

        private void codigoSubRubroValue_KeyUp(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter)
            {
                BuscarSubRubroPorCodigo();
            } 
        }

        private void btnAgregarSubRubro_Click(object sender, RoutedEventArgs e)
        {
            AgregarSubRubro();
        }

        private void btnModificarSubRubro_Click(object sender, RoutedEventArgs e)
        {
            ModificarSubRubro();
        }

        private void btnEliminarSubRubro_Click(object sender, RoutedEventArgs e)
        {
            EliminarSubRubro();
        }

        private void btnLimpiarSubRubro_Click(object sender, RoutedEventArgs e)
        {
            LimpiarCamposSubRubros();
        }

        private void btnCambiarCodigoSubRubro_Click(object sender, RoutedEventArgs e)
        {
            CambiarCodigoSubRubro();
        }

        private void codigoSubRubroValue_GotFocus(object sender, RoutedEventArgs e)
        {
            codigoSubRubroValue.SelectionLength = codigoSubRubroValue.Text.Length;
        }

        private void detalleSubRubroValue_KeyUp(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter)
            {
                BuscarSubRubroPorDescripcion();
            }
        }

        private void detalleSubRubroValue_GotFocus(object sender, RoutedEventArgs e)
        {
            detalleSubRubroValue.SelectionLength = detalleSubRubroValue.Text.Length;
        }

        private void precioSubRubroValue_LostKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
        {
            codigoRubroValue.Focus();
        }

        private void precioSubRubroValue_KeyUp(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter)
            {
                //SubRubroCS auxSubRubro = new SubRubroCS();
                //auxSubRubro.IdRubro = AdaptarString(codigoRubroValue.Text);
                //auxSubRubro.IdSubRubro = AdaptarString(codigoSubRubroValue.Text);
                //auxSubRubro = rubroDB.ObtenerSubRubroPorCodigo(auxSubRubro);

                //if (auxSubRubro.IdSubRubro.Equals(""))
                //{
                //    AgregarSubRubro();
                //}
                if (btnAgregarSubRubro.IsEnabled)
                {
                    AgregarSubRubro();
                }
                else if (btnModificarSubRubro.IsEnabled)
                {
                    ModificarSubRubro();
                }
            }
        }

        private void precioSubRubroValue_GotFocus(object sender, RoutedEventArgs e)
        {
            precioSubRubroValue.SelectionLength = precioSubRubroValue.Text.Length;
        }

        #endregion

        #endregion

        #region Auxiliar Methods

        #region Rubros Auxiliar

        private void AgregarRubro()
        {
            string codigoRubro = AdaptarString(this.codigoRubroValue.Text);
            if (codigoRubro.Equals(""))
            {
                MessageBox.Show("Debe ingresar un codigo para el Rubro");
                return;
            }

            string descripcionRubro = AdaptarString(this.detalleRubroValue.Text);
            if (descripcionRubro.Equals(""))
            {
                MessageBox.Show("Debe ingresar una descripcion para el rubro");
                return;
            }

            RubroCS nuevoAuxRubro = new RubroCS();
            nuevoAuxRubro.IdRubro = codigoRubro;
            nuevoAuxRubro.Descripcion = descripcionRubro;

            int resultadoConsulta = rubroDB.AddRubro(nuevoAuxRubro, true, forzadoAgregarRubro);

            if (resultadoConsulta == 1)
            {
                _rubro = nuevoAuxRubro;
            }
            BotonesRubroModoModificar();
            if (forzadoAgregarRubro)
                forzadoAgregarRubro = false;
        }

        private void ModificarRubro()
        {
            string viejoCodigoRubro = _rubro.IdRubro;
            string nuevoCodigoRubro = AdaptarString(this.codigoRubroValue.Text.ToUpper());
            if (nuevoCodigoRubro.Equals(""))
            {
                MessageBox.Show("Debe ingresar un codigo para el Rubro");
                return;
            }
            
            RubroCS auxViejoRubro = new RubroCS();
            auxViejoRubro.IdRubro = viejoCodigoRubro;
            RubroCS auxRubro = rubroDB.ObtenerRubroPorCodigoExacto(auxViejoRubro);

            if (!auxRubro.IdRubro.Trim().Equals(""))
            {
                string descripcionRubro = AdaptarString(this.detalleRubroValue.Text);
                if (descripcionRubro.Equals(""))
                {
                    MessageBox.Show("Debe ingresar una descripcion para el rubro");
                    return;
                }

                auxRubro.Descripcion = descripcionRubro;
                RubroCS auxNuevoRubro = new RubroCS();
                auxNuevoRubro.IdRubro = nuevoCodigoRubro;
                rubroDB.UpdateRubro(auxRubro, auxNuevoRubro);
            }
            else
            {
                MessageBox.Show("No puede modificar un rubro que no esta cargado", "Atencion", MessageBoxButton.OK, MessageBoxImage.Information);
            }
        }

        private void EliminarRubro()
        {

            string auxCodigoRubro = AdaptarString(this.codigoRubroValue.Text);
           
            RubroCS auxRubro = new RubroCS();
            auxRubro.IdRubro = auxCodigoRubro;
            RubroCS rubro = rubroDB.ObtenerRubroPorCodigoExacto(auxRubro);

            List<SubRubroCS> subRubrosDelRubro = rubroDB.ObtenerSubRubrosPorCodigoDeRubro(rubro);

            int cantidadSubArticulos = subRubrosDelRubro.Count;

            string resultadoParaMessageBoxInicial = "Realmente desea eliminar el Rubro " + rubro.Descripcion + " ?\n";

            string resultadoMessageBoxFinal = resultadoParaMessageBoxInicial;

            if (cantidadSubArticulos > 0)
            {
                string resultadoParaMessageBox = "\n";
                int contador = 1;
                foreach (SubRubroCS item in subRubrosDelRubro)
                {
                    resultadoParaMessageBox = resultadoParaMessageBox + contador + " --> " + item.Descripcion + " -- $" + item.Precio.ToString() + " \n";
                    contador++;
                }
                resultadoParaMessageBox = resultadoParaMessageBox + "\n";

                resultadoMessageBoxFinal = resultadoMessageBoxFinal + "No estaran disponibles los siguientes Sub Rubros si elimina el Rubro: " + rubro.Descripcion + "\n" + resultadoParaMessageBox;

            }

            MessageBoxResult resultadoOK = MessageBox.Show(resultadoMessageBoxFinal, "Eliminar Rubro", MessageBoxButton.YesNoCancel, MessageBoxImage.Exclamation);

            int resultadoConsulta = 0;

            switch (resultadoOK.ToString())
            {
                case "Yes":
                    resultadoConsulta = rubroDB.EliminarRubro(rubro);
                    break;
                default:
                    return;
            }

            if (resultadoConsulta == 1)
            {
                MessageBox.Show("Rubro: " + rubro.Descripcion + " ELIMINADO!!", "Eliminar Rubro", MessageBoxButton.OK, MessageBoxImage.Information);
                LimpiarCamposRubro();
                LimpiarCamposSubRubros();
                BotonesRubroModoAgregar();
                BotonesSubRubroModoAgregar();
                LimpiarDataGrid();
            }

            CargarSubRubros();
        }

        private void LimpiarCamposRubro()
        {
            this.codigoRubroValue.Text = "";
            this.detalleRubroValue.Text = "";
            this.btnAgregarRubro.IsEnabled = false;
        }

        private void CambiarCodigoRubro()
        {
            string codigoRubro = AdaptarString(this.codigoRubroValue.Text);
            if (!codigoRubro.Equals(""))
            {
                RubroCS auxRubro = new RubroCS();
                auxRubro.IdRubro = _rubro.IdRubro;
                string newCodigo = Microsoft.VisualBasic.Interaction.InputBox("Ingrese el nuevo Codigo a sustituir", "Nuevo Codigo", _rubro.IdRubro, 10, 10);
                if (!newCodigo.Trim().Equals(""))
                {
                    newCodigo = AdaptarString(newCodigo);
                    
                    if (newCodigo.Length > 4)
                    {
                        MessageBox.Show("No puede poner un codigo mayor a 4 caracteres", "Atencion", MessageBoxButton.OK, MessageBoxImage.Information);
                        return;
                    }

                    RubroCS auxNuevoRubro = new RubroCS();
                    auxNuevoRubro.IdRubro = newCodigo;

                    auxNuevoRubro = rubroDB.ObtenerRubroPorCodigoExacto(auxNuevoRubro);

                    if (auxNuevoRubro.IdRubro.Equals(""))
                    {
                        auxNuevoRubro.IdRubro = newCodigo;
                        rubroDB.CambiarCodigoRubro(auxRubro, auxNuevoRubro);
                        this.codigoRubroValue.Text = newCodigo;
                    }
                    else
                    {
                        MessageBox.Show("El codigo " + auxNuevoRubro.IdRubro.ToUpper() + " esta siendo utilizado por el rubro " + auxNuevoRubro.Descripcion.ToUpper());
                    }
                }
                else
                {
                    this.codigoRubroValue.Text = auxRubro.IdRubro;
                }

            }
            else
            {
                MessageBox.Show("Debe cargar un codigo de Rubro", "Cambiar Codigo de Rubro");
            }
            CargarSubRubros();
        }

        private void BotonesRubroModoAgregar()
        {
            btnAgregarRubro.IsEnabled = true;
            btnModificarRubro.IsEnabled = false;
            btnCambiarCodigoRubro.IsEnabled = false;
            btnEliminarRubro.IsEnabled = false;
        }

        private void BotonesRubroModoModificar()
        {
            btnAgregarRubro.IsEnabled = false;
            btnModificarRubro.IsEnabled = true;
            btnCambiarCodigoRubro.IsEnabled = true;
            btnEliminarRubro.IsEnabled = true;
        }

        private void BuscarRubroPorCodigo()
        {
            string auxCodigoRubro = AdaptarString(this.codigoRubroValue.Text);

            if (auxCodigoRubro.Length > 0 && auxCodigoRubro.Length < 5)
            {
                RubroCS auxRubro = new RubroCS();
                auxRubro.IdRubro = auxCodigoRubro;

                List<RubroCS> _rubros = rubroDB.ObtenerRubrosPorCodigo(auxRubro);

                if (_rubros.Count == 0)
                {
                    BotonesRubroModoAgregar();
                    LimpiarCamposSubRubros();
                    BotonesSubRubroModoAgregar();
                    detalleRubroValue.Text = "";
                    CargarSubRubros();
                }
                else if (_rubros.Count == 1)
                {
                    _rubro = rubroDB.ObtenerRubroPorCodigo(auxRubro);

                    if (_rubro.IdRubro.Trim().Equals(""))
                    {
                        BotonesRubroModoAgregar();
                        LimpiarCamposSubRubros();
                        BotonesSubRubroModoAgregar();
                    }
                    else
                    {
                        BotonesRubroModoModificar();
                        BotonesSubRubroModoModificar();
                    }

                    this.codigoRubroValue.Text = _rubro.IdRubro;
                    this.detalleRubroValue.Text = _rubro.Descripcion;
                    CargarSubRubros();
                }
                else if (_rubros.Count > 1)
                {
                    Ventana_RubrosEncontrados(_rubros);
                }

                RefrescarCamposSubRubro();
            }
        }

        private void BuscarRubroPorDescripcion()
        {
            string auxDescripcionRubro = AdaptarString(this.detalleRubroValue.Text);

            if (auxDescripcionRubro.Length > 0 && auxDescripcionRubro.Length < 5)
            {
                RubroCS auxRubro = new RubroCS();
                auxRubro.Descripcion = auxDescripcionRubro;

                List<RubroCS> _rubros = rubroDB.ObtenerRubrosPorDescripcion(auxRubro);

                if (_rubros.Count == 0)
                {
                    BotonesRubroModoAgregar();
                    LimpiarCamposSubRubros();
                    BotonesSubRubroModoAgregar();
                    detalleRubroValue.Text = "";
                    CargarSubRubros();
                }
                else if (_rubros.Count == 1)
                {
                    _rubro = rubroDB.ObtenerRubroPorDescripcion(auxRubro);

                    if (_rubro.IdRubro.Trim().Equals(""))
                    {
                        BotonesRubroModoAgregar();
                        LimpiarCamposSubRubros();
                    }
                    else
                    {
                        BotonesRubroModoModificar();
                    }

                    this.codigoRubroValue.Text = _rubro.IdRubro;
                    this.detalleRubroValue.Text = _rubro.Descripcion;
                    CargarSubRubros();
                }
                else if (_rubros.Count > 1)
                {
                    Ventana_RubrosEncontrados(_rubros);
                }

                RefrescarCamposSubRubro();
            }
        }

        private void Ventana_RubrosEncontrados(List<RubroCS> _rubrosEncontrados)
        {
            RubrosEncontrados encontrados = new RubrosEncontrados(_rubrosEncontrados);

            encontrados.enviarRubro = new RubrosEncontrados.EnviarRubro(PassDataRubro);

            encontrados.ShowInTaskbar = false;
            encontrados.Owner = this; AplicarEfecto(this);
            encontrados.ShowDialog();
            bool?
            resultado = encontrados.DialogResult;
            if (resultado != null)
            {
                if (resultado == false)
                {
                    QuitarEfecto(this);
                }
            }
        }

        private void PassDataRubro(RubroCS sender)
        {
            _rubro = rubroDB.ObtenerRubroPorCodigoExacto(sender);
            this.codigoRubroValue.Text = _rubro.IdRubro;
            this.detalleRubroValue.Text = _rubro.Descripcion;
            CargarSubRubros();
            RefrescarCamposSubRubro();
        }

        private void AplicarEfecto(Window win)
        {
            var objBlur = new System.Windows.Media.Effects.BlurEffect();
            objBlur.Radius = 3;
            win.Effect = objBlur;
        }

        private void QuitarEfecto(Window win)
        {
            win.Effect = null;
        }

        #endregion

        #region SubRubros Auxiliar

        private void CargarSubRubros()
        {
            string auxCodigoRubro = AdaptarString(this.codigoRubroValue.Text);

            if (!auxCodigoRubro.Equals(null) || !auxCodigoRubro.Equals(""))
            {
                RubroCS auxRubro = new RubroCS();
                auxRubro.IdRubro = RellenarCodigo(auxCodigoRubro);
                subRubros = rubroDB.ObtenerSubRubrosPorCodigoDeRubro(auxRubro);

                IComparer<SubRubroCS> comparer = new MyOrderingSubRubro();

                if (subRubros.Count > 0)
                {
                    subRubros.Sort(comparer);
                    dataGridSubRubros.ItemsSource = subRubros;
                }
                else
                {
                    dataGridSubRubros.ItemsSource = new List<SubRubroCS>();
                    LimpiarCamposSubRubros();
                }
                dataGridSubRubros.Items.Refresh();
            }
            else
            {
                LimpiarCamposRubro();
                LimpiarCamposSubRubros();
            }
        }

        private void CargarTodosSubRubros()
        {
            subRubros = rubroDB.ObtenerSubRubros();

            IComparer<SubRubroCS> comparer = new MyOrderingSubRubro();

            if (subRubros.Count > 0)
            {
                subRubros.Sort(comparer);

                dataGridSubRubros.ItemsSource = subRubros;
            }
            dataGridSubRubros.Items.Refresh();

            if (subRubros.Count > 0)
            {
                RubroCS auxRubro = new RubroCS();

                auxRubro.IdRubro = subRubros[0].IdRubro;
                _rubro = rubroDB.ObtenerRubroPorCodigo(auxRubro);
                DataContext = _rubro;
                ReasignarDataContext(subRubros[0]);
            }
        }

        private void AgregarSubRubro()
        {
            string codigoRubro = AdaptarString(this.codigoRubroValue.Text);
            string codigoSubRubro = AdaptarString(this.codigoSubRubroValue.Text);
            
            string descripcionSubRubro = AdaptarString(this.detalleSubRubroValue.Text);
            if (descripcionSubRubro.Equals(""))
            {
                MessageBox.Show("El Sub Rubro DEBE tener una descripción");
                return;
            }

            string precioString = (this.precioSubRubroValue.Text.Contains(".") ? this.precioSubRubroValue.Text.Replace(".", ",") : this.precioSubRubroValue.Text);
            decimal precioSubRubro = (string.IsNullOrEmpty(precioString)) ? 0 : Convert.ToDecimal(precioString.Trim());
            if (precioSubRubro == 0 || precioSubRubro < 0)
            {
                MessageBox.Show("El Sub Rubro NO DEBE tener un precio $ 0,00 o negativo");
                return;
            }

            SubRubroCS nuevoAuxSubRubro = new SubRubroCS();
            nuevoAuxSubRubro.IdRubro = codigoRubro;
            nuevoAuxSubRubro.IdSubRubro = codigoSubRubro;
            nuevoAuxSubRubro.Descripcion = descripcionSubRubro;
            nuevoAuxSubRubro.Precio = precioSubRubro;
            rubroDB.AddSubRubro(nuevoAuxSubRubro);

            CargarSubRubros();
            BotonesSubRubroModoModificar();
            this.codigoSubRubroValue.Text = RellenarCodigo(nuevoAuxSubRubro.IdSubRubro);
        }

        private void ModificarSubRubro()
        {
            SubRubroCS auxSubRubro = (SubRubroCS)dataGridSubRubros.SelectedItem;

            if (dataGridSubRubros.SelectedItems.Count == 1)
            {
                _subRubro = rubroDB.ObtenerSubRubroPorCodigo(auxSubRubro);
            }
            else
            {
                string codigoRubro = AdaptarString(this.codigoRubroValue.Text);
                string codigoSubRubro = AdaptarString(this.codigoSubRubroValue.Text);
                
                SubRubroCS auxiliarSubRubro = new SubRubroCS();
                auxiliarSubRubro.IdRubro = codigoRubro;
                auxiliarSubRubro.IdSubRubro = codigoSubRubro;

                _subRubro = rubroDB.ObtenerSubRubroPorCodigo(auxiliarSubRubro);
            }

            string subRubroCodigo = AdaptarString(this.codigoSubRubroValue.Text);
            string descripcion = AdaptarString(this.detalleSubRubroValue.Text);

            if (dataGridSubRubros.SelectedItems.Count == 1 || (!subRubroCodigo.Equals("") && !descripcion.Equals("")))
            {
                string codigoRubroModificar = AdaptarString(_subRubro.IdRubro);
                string codigoSubRubroModificar = AdaptarString(_subRubro.IdSubRubro);
                
                SubRubroCS auxiliarSubRubro = new SubRubroCS();
                auxiliarSubRubro.IdRubro = codigoRubroModificar;
                auxiliarSubRubro.IdSubRubro = codigoSubRubroModificar;

                SubRubroCS auxSubRubroModificar = rubroDB.ObtenerSubRubroPorCodigo(auxiliarSubRubro);

                if (!auxSubRubroModificar.IdRubro.Trim().Equals("") && !auxSubRubroModificar.IdSubRubro.Trim().Equals(""))
                {
                    string descripcionSubRubro = AdaptarString(this.detalleSubRubroValue.Text);
                    if (descripcionSubRubro.Equals(""))
                    {
                        MessageBox.Show("El Sub Rubro DEBE tener una descripcion");
                        return;
                    }

                    auxSubRubroModificar.Descripcion = descripcionSubRubro;

                    string precioString = (this.precioSubRubroValue.Text.Contains(".") ? this.precioSubRubroValue.Text.Replace(".", ",") : this.precioSubRubroValue.Text);
                    decimal precioSubRubro = Convert.ToDecimal(precioString.Trim());
                    if (precioSubRubro == 0 || precioSubRubro < 0)
                    {
                        MessageBox.Show("El Sub Rubro NO DEBE tener un precio $ 0,00 o negativo");
                        return;
                    }

                    auxSubRubroModificar.Precio = precioSubRubro;
                    
                    rubroDB.UpdateSubRubro(auxSubRubroModificar,auxSubRubroModificar);
                }
            }
            else
            {
                MessageBox.Show("No puede modificar un sub rubro que no esta cargado", "Atencion", MessageBoxButton.OK, MessageBoxImage.Information);
            }

            CargarSubRubros();
            LimpiarCamposSubRubros();
        }

        private void EliminarSubRubro()
        {
            SubRubroCS auxSubRubro = (SubRubroCS)dataGridSubRubros.SelectedItem;
            if (dataGridSubRubros.SelectedItems.Count == 1)
            {
                _subRubro = rubroDB.ObtenerSubRubroPorCodigo(auxSubRubro);
            }
            else
            {
                string codigoRubro = AdaptarString(this.codigoRubroValue.Text);
                string codigoSubRubro = AdaptarString(this.codigoSubRubroValue.Text);
                
                SubRubroCS auxiliarSubrubro = new SubRubroCS();
                auxiliarSubrubro.IdRubro = codigoRubro;
                auxiliarSubrubro.IdSubRubro = codigoSubRubro;

                _subRubro = rubroDB.ObtenerSubRubroPorCodigo(auxiliarSubrubro);
            }

            string subRubroCodigo = AdaptarString(this.codigoSubRubroValue.Text);
            string descripcion = AdaptarString(this.detalleSubRubroValue.Text);

            if (dataGridSubRubros.SelectedItems.Count == 1 || (!subRubroCodigo.Equals("") && !descripcion.Equals("")))
            {
                string codigoRubroEliminar = AdaptarString(_subRubro.IdRubro);
                string codigoSubRubroEliminar = AdaptarString(_subRubro.IdSubRubro);
                
                SubRubroCS auxiliarSubRubro = new SubRubroCS();
                auxiliarSubRubro.IdRubro = codigoRubroEliminar;
                auxiliarSubRubro.IdSubRubro = codigoSubRubroEliminar;

                SubRubroCS auxSubRubroEliminar = rubroDB.ObtenerSubRubroPorCodigo(auxiliarSubRubro);

                List<CotizarArticulosCS> articulosCotizadosAux = new List<CotizarArticulosCS>();
                List<CotizarArticulosCS> articulosCotizados = new List<CotizarArticulosCS>();

                articulosCotizadosAux = cotizarDB.ObtenerCotizarArticulosPorRubro_y_SubRubro(auxSubRubroEliminar);

                IComparer<CotizarArticulosCS> comparer = new MyOrderingCotizarArticulo();

                articulosCotizadosAux.Sort(comparer);

                articulosCotizados = articulosCotizadosAux;
                
                int cantidadArticulosCotizados = articulosCotizados.Count;

                string resultadoParaMessageBoxInicial = "Realmente desea eliminar el Sub Rubro " + auxSubRubroEliminar.Descripcion + " ?\n";
                string resultadoMessageBoxFinal = resultadoParaMessageBoxInicial;

                if (cantidadArticulosCotizados > 0)
                {
                    string resultadoParaMessageBox = "\n";
                    int contador = 1;
                    foreach (CotizarArticulosCS item in articulosCotizados)
                    {
                        resultadoParaMessageBox = resultadoParaMessageBox + contador + " --> " + "Codigo Articulo: " + item.IdArticulo + " ";
                        resultadoParaMessageBox += "Cantidad del Articulo: " + item.CantidadArticulos + " ";
                        resultadoParaMessageBox += "Cantidades: " + item.Cantidad + "\n"; ;
                        contador++;
                    }
                    resultadoParaMessageBox = resultadoParaMessageBox + "\n";
                    if (cantidadArticulosCotizados == 1)
                    {
                        resultadoMessageBoxFinal = resultadoMessageBoxFinal + "No estaran disponibles la siguiente Cotizacion de Articulo si elimina el Sub Rubro: " + auxSubRubroEliminar.Descripcion + "\n" + resultadoParaMessageBox;
                    }
                    else
                    {
                        resultadoMessageBoxFinal = resultadoMessageBoxFinal + "No estaran disponibles las siguientes " + cantidadArticulosCotizados + " Cotizaciones de Articulos si elimina el Sub Rubro: " + auxSubRubroEliminar.Descripcion + "\n" + resultadoParaMessageBox;
                    }

                }

                MessageBoxResult resultadoBox = MessageBox.Show(resultadoMessageBoxFinal,"Atencion",MessageBoxButton.YesNoCancel,MessageBoxImage.Exclamation);

                if (resultadoBox.ToString().ToUpper().Equals("YES"))
                {
                    int resultadoCotizar = cotizarDB.EliminarCotizacionesDeArticulosSegunElSubRubro(auxSubRubroEliminar);

                    if (resultadoCotizar == 1)
                    {
                        int resultadoSubRubro = rubroDB.EliminarSubRubro(auxSubRubroEliminar);

                        if (resultadoSubRubro == 1)
                        {
                            MessageBox.Show("Sub Rubro " + auxSubRubroEliminar.Descripcion + " ELIMINADO!");
                        }
                    }
                    else if (cantidadArticulosCotizados == 0)
                    {
                        int resultadoSubRubro = rubroDB.EliminarSubRubro(auxSubRubroEliminar);

                        if (resultadoSubRubro == 1)
                        {
                            MessageBox.Show("Sub Rubro " + auxSubRubroEliminar.Descripcion + " ELIMINADO!");
                        }
                    }
                }
            }
            else
            {
                MessageBox.Show("No puede eliminar un sub rubro que no esta cargado", "Atencion", MessageBoxButton.OK, MessageBoxImage.Information);
            }

            CargarSubRubros();
            LimpiarCamposSubRubros();
        }

        private void LimpiarCamposSubRubros()
        {
            this.codigoSubRubroValue.Text = "";
            this.detalleSubRubroValue.Text = "";
            this.precioSubRubroValue.Text = "";
        }

        private void CambiarCodigoSubRubro()
        {
            string codigoSubRubro = AdaptarString(this.codigoSubRubroValue.Text);
            if (!codigoSubRubro.Equals(""))
            {
                SubRubroCS auxSubRubro = new SubRubroCS();
                auxSubRubro.IdSubRubro = _subRubro.IdSubRubro;
                string newCodigo = Microsoft.VisualBasic.Interaction.InputBox("Ingrese el nuevo Codigo a sustituir", "Nuevo Codigo", _subRubro.IdSubRubro, 10, 10);
                if (!newCodigo.Trim().Equals(""))
                {
                    newCodigo = AdaptarString(newCodigo);
                    
                    if (newCodigo.Length > 4)
                    {
                        MessageBox.Show("No puede poner un codigo mayor a 4 caracteres", "Atencion", MessageBoxButton.OK, MessageBoxImage.Information);
                        return;
                    }

                    SubRubroCS nuevoSubRubro = new SubRubroCS();
                    nuevoSubRubro.IdSubRubro = newCodigo;
                    nuevoSubRubro.IdRubro = _rubro.IdRubro;

                    nuevoSubRubro = rubroDB.ObtenerSubRubroPorCodigo(nuevoSubRubro);

                    if (nuevoSubRubro.IdSubRubro.Equals(""))
                    {
                        nuevoSubRubro.IdSubRubro = newCodigo;
                        nuevoSubRubro.IdRubro = _rubro.IdRubro;
                        rubroDB.CambiarCodigoSubRubro(_subRubro, nuevoSubRubro);
                        this.codigoRubroValue.Text = _rubro.IdRubro;
                        _subRubro.IdSubRubro = RellenarCodigo(nuevoSubRubro.IdSubRubro);
                        this.codigoSubRubroValue.Text = _subRubro.IdSubRubro;
                        ReasignarDataContext(_subRubro);
                    }
                    else
                    {
                        MessageBox.Show("El codigo " + nuevoSubRubro.IdSubRubro.ToUpper() + " esta siendo utilizado por el subRubro " + nuevoSubRubro.Descripcion.ToUpper() + " del Rubro " + _rubro.Descripcion);
                    }

                    
                }
                else
                {
                    this.codigoSubRubroValue.Text = auxSubRubro.IdSubRubro;
                }
            }
            else
            {
                MessageBox.Show("Debe cargar un codigo de Sub Rubro","Cambiar Codigo de Sub Rubro");
            }
            CargarSubRubros();
        }

        private void BotonesSubRubroModoAgregar()
        {
            btnAgregarSubRubro.IsEnabled = true;
            btnModificarSubRubro.IsEnabled = false;
            btnCambiarCodigoSubRubro.IsEnabled = false;
            btnEliminarSubRubro.IsEnabled = false;
        }

        private void BotonesSubRubroModoModificar()
        {
            btnAgregarSubRubro.IsEnabled = false;
            btnModificarSubRubro.IsEnabled = true;
            btnCambiarCodigoSubRubro.IsEnabled = true;
            btnEliminarSubRubro.IsEnabled = true;
        }

        private void BuscarSubRubroPorCodigo()
        {
            string auxCodigoRubro = AdaptarString(this.codigoRubroValue.Text);
            string auxCodigoSubRubro = AdaptarString(this.codigoSubRubroValue.Text);
            
            if (auxCodigoRubro.Length > 0 && (auxCodigoSubRubro.Length > 0 && auxCodigoSubRubro.Length < 5))
            {
                SubRubroCS auxiliarSubRubro = new SubRubroCS();
                auxiliarSubRubro.IdRubro = RellenarCodigo(auxCodigoRubro);
                auxiliarSubRubro.IdSubRubro = RellenarCodigo(auxCodigoSubRubro);

                _subRubro = rubroDB.ObtenerSubRubroPorCodigo(auxiliarSubRubro);

                if (!_rubro.IdRubro.Trim().Equals("") && _subRubro.IdSubRubro.Trim().Equals(""))
                {
                    BotonesSubRubroModoAgregar();
                }
                else
                {
                    BotonesSubRubroModoModificar();
                    this.codigoSubRubroValue.Text = _subRubro.IdSubRubro;
                }
                
                this.detalleSubRubroValue.Text = _subRubro.Descripcion;
                this.precioSubRubroValue.Text = _subRubro.Precio.ToString();
                CargarSubRubros();
            }
        }

        private void BuscarSubRubroPorDescripcion()
        {
            string auxSubRubroDescripcion = AdaptarString(this.detalleSubRubroValue.Text);

            if (auxSubRubroDescripcion.Length > 1)
            {
                SubRubroCS _subRubro = new SubRubroCS();
                _subRubro.Descripcion = auxSubRubroDescripcion;

                dataGridSubRubros.ItemsSource = rubroDB.ObtenerSubRubrosPorDescripcion(_subRubro);
                dataGridSubRubros.Items.Refresh();

                dataGridSubRubros.SelectedIndex = 0;

                SubRubroCS auxSubRubro = (SubRubroCS)dataGridSubRubros.SelectedItem;

                
                this.codigoRubroValue.Text = auxSubRubro.IdRubro;
                RubroCS auxRubro = new RubroCS();
                auxRubro.IdRubro = auxSubRubro.IdRubro;
                this.detalleRubroValue.Text = rubroDB.ObtenerRubroPorCodigoExacto(auxRubro).Descripcion;
                this.codigoSubRubroValue.Text = auxSubRubro.IdSubRubro;
                this.detalleSubRubroValue.Text = auxSubRubro.Descripcion;
                this.precioSubRubroValue.Text = auxSubRubro.Precio.ToString();
            }
        }

        #endregion 

        private void LimpiarDataGrid()
        {
            subRubros = new List<SubRubroCS>();
            dataGridSubRubros.ItemsSource = new List<SubRubroCS>();
            dataGridSubRubros.Items.Refresh();
        }

        //private void GenerarArchivo()
        //{
        //    GenerarArchivosDeSubRubros ventanaGenerarArchivo = new GenerarArchivosDeSubRubros();
        //    ventanaGenerarArchivo.Show();
        //}

        private void Salir()
        {
            this.Close();
        }

        private string AdaptarString(string cadena)
        {
            return cadena.Trim().ToUpper();
        }

        private void ReasignarDataContext(SubRubroCS subRubro)
        {
            this.codigoSubRubroValue.DataContext = subRubro;
            this.detalleSubRubroValue.DataContext = subRubro;
            this.precioSubRubroValue.DataContext = subRubro;

            this.codigoSubRubroValue.Text = subRubro.IdSubRubro;
            this.detalleSubRubroValue.Text = subRubro.Descripcion;
            this.precioSubRubroValue.Text = subRubro.Precio.ToString();
        }

        private void RefrescarCamposSubRubro()
        {
            if (subRubros.Count > 0)
            {
                dataGridSubRubros.SelectedIndex = 0;
                ReasignarDataContext(subRubros[0]);
            }
            else
            {
                ReasignarDataContext(new SubRubroCS());
            }
        }

        private void Listar()
        {
            string miRdlc = "CalculoPreciosUnitarios.Ventanas.Listados.Listado_Rubro.RptSubRubro.rdlc";
            string miNameDataSet = "DataSetSubRubro";

            List<SubRubroCS> listaSubRubro = subRubros;
            IComparer<SubRubroCS> comparer = new MyOrderingSubRubro();
            listaSubRubro = AgregarDescripcionRubro_a_SubRubros(listaSubRubro);
            listaSubRubro.Sort(comparer);
            FReporte rp = new FReporte(listaSubRubro, miRdlc, miNameDataSet, 1);
            rp.Show();
        }

        private List<SubRubroCS> AgregarDescripcionRubro_a_SubRubros(List<SubRubroCS> _subRubros)
        {
            List<SubRubroCS> resultado = new List<SubRubroCS>();

            if (_subRubros.Count > 0)
            {
                foreach (SubRubroCS item in _subRubros)
                {
                    RubroCS auxRubro = new RubroCS();
                    auxRubro.IdRubro = item.IdRubro;
                    item.DescripcionRubro = rubroDB.ObtenerRubroPorCodigoExacto(auxRubro).Descripcion;

                    resultado.Add(item);
                }
            }

            return resultado;
        }

        private string RellenarCodigo(string codigo)
        {
            return codigo.PadLeft(4, '0');
        }

        #endregion
    }
}